/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package moteur.paquet;

import java.util.Vector;
import moteur.Transport;

/**
 *
 * @author Administrateur
 */
public class PionsEnMain extends PaquetEnum<Transport> {

    private byte[] caché;

    /**
     *
     */
    public PionsEnMain() {
        super();
        paquet = new byte[Transport.values().length - 1]; //pas de kayak
        caché = new byte[Transport.values().length - 1]; //pas de kayak
    }

    @Override
    public String toString() {
        String str = "";

        Transport[] t = Transport.values();
        int fin = t.length - 1;
        for (int i = 0; i < fin; i++) {
            str += t[i].toString() + " : " + paquet[t[i].ordinal()] + "\n";
        }
        return str;
    }

    /**
     * Mélange aussi les pions cachés.
     * @param dest
     * @throws TypeMismatchException
     * @throws PaquetVideException
     */
    @Override
    public void melanger(PaquetEnum dest) throws TypeMismatchException, PaquetVideException {
        super.melanger(dest);

        int t = caché.length;
        for(int i = 0; i< t; i++){
        dest.paquet[i]+=caché[i];
        caché[i]=0;
        }

        }


    /**
     *
     * @return
     */
    public String toStringCaché() {
        String str = "";

        Transport[] t = Transport.values();
        int fin = t.length - 1;
        for (int i = 0; i < fin; i++) {
            str += t[i].toString() + " : " + caché[t[i].ordinal()] + "\n";
        }
        return str;
    }

    /**
     * Suceptible de servir ulterieurement.
     * Private pour le moment car malsain.
     * @param e
     */
    private void ajouter(Enum e) {
        paquet[e.ordinal()] += 1;
    }

    /**
     * Suceptible de servir ulterieurement.
     * Private pour le moment car malsain.
     * @param e
     */
    private void retirer(Enum e) {
        paquet[e.ordinal()] -= 1;
    }


    public void retirerCaché(int i) {
        caché[i]--;
    }

    public void retirerSiPossible(Enum e){
        int i = e.ordinal();
        if (paquet[i] > 0){paquet[i]--;}else{
        if (caché[i] > 0){caché[i]--;}
        }
    }

    /**
     * Pioche un pion, et le cache.
     * @param from
     * @throws PaquetVideException
     * @throws TypeMismatchException
     */
    public void piocherCaché(PaquetEnum from) throws PaquetVideException, TypeMismatchException {
        if (!this.getType().equals(from.getType())) {
            throw new TypeMismatchException();
        }

        int taille = this.caché.length;
        int total = from.total(); //total() doit gerer l'exception

        int tmp = (int) (Math.random() * total);
        for (int i = 0; i < taille; i++) {
            tmp -= from.paquet[i];
            if (tmp < 0) {
                from.paquet[i]--;
                this.caché[i]++;
                break;
            }
        }
    }

    /**
     * Récupere un tableau indiquant la disponibilité d'un type de pion.
     * @return
     */
    public Boolean[] getDispo(){
    Boolean[] Dispo = new Boolean[paquet.length];

    for (int i = 0; i< paquet.length; i++){
        Dispo[i] = (paquet[i]+caché[i] > 0);
    }
    return Dispo;
    }

    /**
     * Total de pion caché.
     * @return
     * @throws PaquetVideException
     */
    public int totalCaché() throws PaquetVideException {

        int accu = 0;
        for (int i = caché.length; --i>= 0;) {
            if (caché[i] < 0) {
                throw new PaquetVideException();
            }
            accu += caché[i];
        }
        
        return accu;
    }
    @Override
    public int total()throws PaquetVideException{

        return super.total()+totalCaché();

    }

    public byte[] getAll(){
    byte[] ret = new byte[super.paquet.length];
    for(int i = super.paquet.length ; --i >= 0;){
        ret[i] += super.paquet[i]+caché[i];
    }
    return ret;
    }

}

